package SBD.CRUD;

import SBD.Servicios.Conexion;
import SBD.Servicios.FactoriaServicios;
import EP.MetricasContenido.OkapiBM25;
import EP.Web.Pagina;
import EP.Web.RelacionPaginas;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* @class ScoreBD
* @author Mauricio Alvarez.
* @brief Contiene los metodos CRUD a la BD para las métricas de ranking.
*/
public class ScoreBD
{

    //////////////////////////
    // OPERACIONES
    //////////////////////////

    /**
     * @brief Guarda los datos de las mediciones Score en la BD segun contenido.
     * @param ResultadosScore, TopicoConsultado, Umbral, Ranking, factorK1, factorb y OpcionContenido
     * @return void
    */
    public void GuardarScore(Map<Integer, List> ResultadosScore,
                             String TopicoConsultado,
                             double Umbral,
                             int Ranking,
                             double factorK1,
                             double factorb,
                             int OpcionContenido) throws java.lang.ClassNotFoundException, java.lang.InstantiationException, java.lang.IllegalAccessException, java.sql.SQLException, Error, Exception
    {

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        //Atributos Score:
        int id_pagina = 0;
        int id_relacion_pag = 0;
        String Termino;
        double TFij_SN = 0;
        double TFij_N = 0;
        double TFij_S = 0;
        double IDF = 0;
        double IDF_O = 0;
        double TfxIDF_SN = 0;
        double TfxIDF_N = 0;
        double TfxIDF_S = 0;
        double TfxIDF_O_SN = 0;
        double TfxIDF_O_N = 0;
        double TfxIDF_O_S = 0;
        double Okapi = 0;


        ////////////////////////////////////////////////////////////////////////
        // BODY   //////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////

        if (OpcionContenido == 1)
        {

            Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

            //Se guardan los parametros de la medición en la tabla TF_IDF:
            cdb.un_sql = "INSERT INTO SCORE(termino, umbral, ranking, factork1_okapi, factorb_okapi) VALUES"
                    + "('" + TopicoConsultado + "','" +  Umbral + "','" + Ranking + "','" + factorK1 + "','" + factorb + "')";
            cdb.un_st.executeUpdate(cdb.un_sql);
            //El ultimo registro ingresado a la Tabla:
            cdb.un_sql = "SELECT id_score FROM SCORE ORDER BY id_score DESC LIMIT 1";
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {
                if (cdb.resultado.next())
                {
                    int id_score = cdb.resultado.getInt("id_score");
                    //Se guardan los resultados de la medición en la tabla MEDICION_SCORE:
                    Set set = ResultadosScore.entrySet();
                    Iterator iter = set.iterator();

                    while(iter.hasNext())
                    {
                        //Se obtiene el par <id_pagina, ArrayList<Score>>
                        Map.Entry me = (Map.Entry)iter.next();
                        //Se obtiene el id_pagina:
                        id_pagina = (Integer) me.getKey();
                        //Se obtiene el ArrayList<Score>:
                        List<OkapiBM25> ListaScores = new ArrayList();
                        ListaScores = (List<OkapiBM25>) me.getValue();

                        //Para cada página con sus puntajes hacer:
                        for (int i=0; i<ListaScores.size(); i++)
                        {
                            //Se obtienen los valores a insertar:
                            Termino = ListaScores.get(i).getTermino();
                            TFij_SN = ListaScores.get(i).getTFij_SN();
                            TFij_N = ListaScores.get(i).getTFij_N();
                            TFij_S = ListaScores.get(i).getTFij_S();
                            IDF = ListaScores.get(i).getIDF();
                            IDF_O = ListaScores.get(i).getIDF_O();
                            TfxIDF_SN = ListaScores.get(i).getTfxIDF_SN();
                            TfxIDF_N = ListaScores.get(i).getTfxIDF_N();
                            TfxIDF_S = ListaScores.get(i).getTfxIDF_S();
                            TfxIDF_O_SN = ListaScores.get(i).getTfxIDF_O_SN();
                            TfxIDF_O_N = ListaScores.get(i).getTfxIDF_O_N();
                            TfxIDF_O_S = ListaScores.get(i).getTfxIDF_O_S();
                            Okapi = ListaScores.get(i).getOkapi();

                            //Se ingresan a la BD:
                            cdb.un_sql = "INSERT INTO MEDICION_SCORE("
                                    + "id_score, "
                                    + "id_pagina, "
                                    + "termino, "
                                    + "TF_SN, "
                                    + "TF_N, "
                                    + "TF_S, "
                                    + "IDF, "
                                    + "IDF_O, "
                                    + "TFXIDF_SN, "
                                    + "TFXIDF_N, "
                                    + "TFXIDF_S, "
                                    + "TFXIDF_O_SN, "
                                    + "TFXIDF_O_N, "
                                    + "TFXIDF_O_S, "
                                    + "OKAPI) "
                                    + "VALUES ('" + id_score + "','"
                                                  + id_pagina + "','"
                                                  + Termino + "',"
                                                  + TFij_SN + ","
                                                  + TFij_N + ","
                                                  + TFij_S + ","
                                                  + IDF + ","
                                                  + IDF_O + ","
                                                  + TfxIDF_SN + ","
                                                  + TfxIDF_N + ","
                                                  + TfxIDF_S + ","
                                                  + TfxIDF_O_SN + ","
                                                  + TfxIDF_O_N + ","
                                                  + TfxIDF_O_S + ","
                                                  + Okapi + ")";
                            cdb.un_st.executeUpdate(cdb.un_sql);


                        }

                    }

                }
            }

        }//FIN IF BODY


        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {

            Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

            //Se guardan los parametros de la medición en la tabla TF_IDF:
            cdb.un_sql = "INSERT INTO SCORE_ST(termino, umbral, ranking, factork1_okapi, factorb_okapi) VALUES"
                    + "( '"+ TopicoConsultado + "','" +  Umbral + "','" + Ranking + "','" + factorK1 + "','" + factorb + "')";
            cdb.un_st.executeUpdate(cdb.un_sql);
            //El ultimo registro ingresado a la Tabla:
            cdb.un_sql = "SELECT id_score_st FROM SCORE_ST ORDER BY id_score_st DESC LIMIT 1";
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {
                if (cdb.resultado.next())
                {
                    int id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se guardan los resultados de la medición en la tabla MEDICION_SCORE:
                    Set set = ResultadosScore.entrySet();
                    Iterator iter = set.iterator();

                    while(iter.hasNext())
                    {
                        //Se obtiene el par <id_relacion_pagina, ArrayList<Score>>
                        Map.Entry me = (Map.Entry)iter.next();
                        //Se obtiene el id_relacion_pagina:
                        id_relacion_pag = (Integer) me.getKey();
                        //Se obtiene el ArrayList<Score>:
                        List<OkapiBM25> ListaScores = new ArrayList();
                        ListaScores = (List<OkapiBM25>) me.getValue();

                        //Para cada página con sus puntajes hacer:
                        for (int i=0; i<ListaScores.size(); i++)
                        {
                            //Se obtienen los valores a insertar:
                            Termino = ListaScores.get(i).getTermino();
                            TFij_SN = ListaScores.get(i).getTFij_SN();
                            TFij_N = ListaScores.get(i).getTFij_N();
                            TFij_S = ListaScores.get(i).getTFij_S();
                            IDF = ListaScores.get(i).getIDF();
                            IDF_O = ListaScores.get(i).getIDF_O();
                            TfxIDF_SN = ListaScores.get(i).getTfxIDF_SN();
                            TfxIDF_N = ListaScores.get(i).getTfxIDF_N();
                            TfxIDF_S = ListaScores.get(i).getTfxIDF_S();
                            TfxIDF_O_SN = ListaScores.get(i).getTfxIDF_O_SN();
                            TfxIDF_O_N = ListaScores.get(i).getTfxIDF_O_N();
                            TfxIDF_O_S = ListaScores.get(i).getTfxIDF_O_S();
                            Okapi = ListaScores.get(i).getOkapi();

                            //Se ingresan a la BD:
                            cdb.un_sql = "INSERT INTO MEDICION_SCORE_ST("
                                    + "id_score_st, "
                                    + "id_relacion_pag, "
                                    + "termino, "
                                    + "TF_SN, "
                                    + "TF_N, "
                                    + "TF_S, "
                                    + "IDF, "
                                    + "IDF_O, "
                                    + "TFXIDF_SN, "
                                    + "TFXIDF_N, "
                                    + "TFXIDF_S, "
                                    + "TFXIDF_O_SN, "
                                    + "TFXIDF_O_N, "
                                    + "TFXIDF_O_S, "
                                    + "OKAPI) "
                                    + "VALUES ('" + id_score_st + "','"
                                                  + id_relacion_pag + "','"
                                                  + Termino + "',"
                                                  + TFij_SN + ","
                                                  + TFij_N + ","
                                                  + TFij_S + ","
                                                  + IDF + ","
                                                  + IDF_O + ","
                                                  + TfxIDF_SN + ","
                                                  + TfxIDF_N + ","
                                                  + TfxIDF_S + ","
                                                  + TfxIDF_O_SN + ","
                                                  + TfxIDF_O_N + ","
                                                  + TfxIDF_O_S + ","
                                                  + Okapi + ")";
                            cdb.un_st.executeUpdate(cdb.un_sql);


                        }

                    }

                }
            }

        }//FIN IF SURROUND TEXT



    }//FIN GuardarScore (OK)


    /**
     * @brief Genera el ranking por métrica de ranking de todas las mediciones, segun contenido.
     * @param ListaPaginas, ListaRelacionPaginas, Consulta, Ranking, Umbral y OpcionContenido.
     * @return void
    */
    public void RankingScores(List<Pagina> ListaPaginas,
                              List<RelacionPaginas> ListaRelacionPaginas,
                              String Consulta,
                              int Ranking,
                              double Umbral,
                              int OpcionContenido) throws ClassNotFoundException, InstantiationException, IOException, IllegalAccessException, SQLException
    {

        //Atributos:
        int id_pagina = 0;
        int id_pagina_destino = 0;
        int id_pagina_fuente = 0;
        int id_relacion_pag = 0;
        int id_score = 0;
        int id_score_st = 0;
        int rank = 1;
        String url = null;
        String url_origen = null;
        String url_destino = null;
        double sum_tf_sn = 0;
        double sum_tf_n = 0;
        double sum_tf_s = 0;
        double sum_tfidf_sn = 0;
        double sum_tfidf_n = 0;
        double sum_tfidf_s = 0;
        double sum_tfidf_o_sn = 0;
        double sum_tfidf_o_n = 0;
        double sum_tfidf_o_s = 0;
        double sum_okapi = 0;

        //Guarda los datos a insertar para TF_SN:
        Map<Integer, List> TF_SN = new HashMap();
        //Guarda los datos a insertar para TF_N:
        Map<Integer, List> TF_N = new HashMap();
        //Guarda los datos a insertar para TF_S:
        Map<Integer, List> TF_S = new HashMap();
        //Guarda los datos a insertar para TFIDF_SN:
        Map<Integer, List> TFIDF_SN = new HashMap();
        //Guarda los datos a insertar para TFIDF_N:
        Map<Integer, List> TFIDF_N = new HashMap();
        //Guarda los datos a insertar para TFIDF_S:
        Map<Integer, List> TFIDF_S = new HashMap();
        //Guarda los datos a insertar para TFIDF_O_SN:
        Map<Integer, List> TFIDF_O_SN = new HashMap();
        //Guarda los datos a insertar para TFIDF_O_N:
        Map<Integer, List> TFIDF_O_N = new HashMap();
         //Guarda los datos a insertar para TFIDF_O_S:
        Map<Integer, List> TFIDF_O_S = new HashMap();
         //Guarda los datos a insertar para OKAPI:
        Map<Integer, List> OKAPI = new HashMap();
        
        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        //Fecha actual:
        java.util.Date fecha = new Date();


        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////
        // BODY   //////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////
        if (OpcionContenido == 1)
        {

            //////////////////////////////////////////////////////////////////
            //PASO 1: Se establece el ranking para TF SIN NORMALIZAR (TF_SN)
            //////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TF_SN) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TF_SN) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tf_sn = cdb.resultado.getDouble("SUM(TF_SN)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TF_SN los datos:
                    List ResultadosTF_SN = new ArrayList();
                    ResultadosTF_SN.add(id_pagina);
                    ResultadosTF_SN.add(id_score);
                    ResultadosTF_SN.add(rank);
                    ResultadosTF_SN.add(url);
                    ResultadosTF_SN.add(sum_tf_sn);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_SN.put(id_pagina, (ArrayList) ResultadosTF_SN);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_SN(TF_SN, OpcionContenido);



            //////////////////////////////////////////////////////////////////
            //PASO 2: Se establece el ranking para TF NORMALISADO(TF_N)
            //////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TF_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TF_N) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tf_n = cdb.resultado.getDouble("SUM(TF_N)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TF_SN los datos:
                    List ResultadosTF_N = new ArrayList();
                    ResultadosTF_N.add(id_pagina);
                    ResultadosTF_N.add(id_score);
                    ResultadosTF_N.add(rank);
                    ResultadosTF_N.add(url);
                    ResultadosTF_N.add(sum_tf_n);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_N.put(id_pagina, (ArrayList) ResultadosTF_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_N(TF_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////
            //PASO 3: Se establece el ranking para TF SUAVISADO (TF_S)
            //////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TF_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TF_S) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {
                
                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tf_s = cdb.resultado.getDouble("SUM(TF_S)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TF_SN los datos:
                    List ResultadosTF_S = new ArrayList();
                    ResultadosTF_S.add(id_pagina);
                    ResultadosTF_S.add(id_score);
                    ResultadosTF_S.add(rank);
                    ResultadosTF_S.add(url);
                    ResultadosTF_S.add(sum_tf_s);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_S.put(id_pagina, (ArrayList) ResultadosTF_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_S(TF_S, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 4: Se establece el ranking para TFIDF SIN NORMALIZAR (TFIDF_SN)
            //////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_SN) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_SN) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_sn = cdb.resultado.getDouble("SUM(TFXIDF_SN)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_SN los datos:
                    List ResultadosTFIDF_SN = new ArrayList();
                    ResultadosTFIDF_SN.add(id_pagina);
                    ResultadosTFIDF_SN.add(id_score);
                    ResultadosTFIDF_SN.add(rank);
                    ResultadosTFIDF_SN.add(url);
                    ResultadosTFIDF_SN.add(sum_tfidf_sn);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TFIDF_SN.put(id_pagina, (ArrayList) ResultadosTFIDF_SN);

                }//FIN while


            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_SN(TFIDF_SN, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 5: Se establece el ranking para TFIDF NORMALISADO (TFIDF_N)
            //////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_N) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_n = cdb.resultado.getDouble("SUM(TFXIDF_N)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_SN los datos:
                    List ResultadosTFIDF_N = new ArrayList();
                    ResultadosTFIDF_N.add(id_pagina);
                    ResultadosTFIDF_N.add(id_score);
                    ResultadosTFIDF_N.add(rank);
                    ResultadosTFIDF_N.add(url);
                    ResultadosTFIDF_N.add(sum_tfidf_n);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TFIDF_N.put(id_pagina, (ArrayList) ResultadosTFIDF_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_N(TFIDF_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 6: Se establece el ranking para TFIDF SUAVISADO (TFIDF_S)
            //////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_S) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_s = cdb.resultado.getDouble("SUM(TFXIDF_S)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_SN los datos:
                    List ResultadosTFIDF_S = new ArrayList();
                    ResultadosTFIDF_S.add(id_pagina);
                    ResultadosTFIDF_S.add(id_score);
                    ResultadosTFIDF_S.add(rank);
                    ResultadosTFIDF_S.add(url);
                    ResultadosTFIDF_S.add(sum_tfidf_s);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TFIDF_S.put(id_pagina, (ArrayList) ResultadosTFIDF_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_S(TFIDF_S, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////////
            //PASO 7: Se establece el ranking para TFIDF SIN NORMALIZAR OKAPI (TFIDF_O_SN)
            //////////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_SN) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_SN) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_o_sn = cdb.resultado.getDouble("SUM(TFXIDF_O_SN)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_SN los datos:
                    List ResultadosTFIDF_O_SN = new ArrayList();
                    ResultadosTFIDF_O_SN.add(id_pagina);
                    ResultadosTFIDF_O_SN.add(id_score);
                    ResultadosTFIDF_O_SN.add(rank);
                    ResultadosTFIDF_O_SN.add(url);
                    ResultadosTFIDF_O_SN.add(sum_tfidf_o_sn);
                    
                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TFIDF_O_SN.put(id_pagina, (ArrayList) ResultadosTFIDF_O_SN);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_O_SN(TFIDF_O_SN, OpcionContenido);




            //////////////////////////////////////////////////////////////////////////////
            //PASO 8: Se establece el ranking para TFIDF SIN NORMALIZADO OKAPI (TFIDF_O_N)
            //////////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_N) DESC LIMIT "+ Ranking +";";
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_o_n = cdb.resultado.getDouble("SUM(TFXIDF_O_N)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_O_N los datos:
                    List ResultadosTFIDF_O_N = new ArrayList();
                    ResultadosTFIDF_O_N.add(id_pagina);
                    ResultadosTFIDF_O_N.add(id_score);
                    ResultadosTFIDF_O_N.add(rank);
                    ResultadosTFIDF_O_N.add(url);
                    ResultadosTFIDF_O_N.add(sum_tfidf_o_n);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TFIDF_O_N.put(id_pagina, (ArrayList) ResultadosTFIDF_O_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_N:
            GuardarRankingScoreTFIDF_O_N(TFIDF_O_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////////
            //PASO 9: Se establece el ranking para TFIDF SUAVISADO OKAPI (TFIDF_O_S)
            //////////////////////////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_S) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tfidf_o_s = cdb.resultado.getDouble("SUM(TFXIDF_O_S)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo TFIDF_O_S los datos:
                    List ResultadosTFIDF_O_S = new ArrayList();
                    ResultadosTFIDF_O_S.add(id_pagina);
                    ResultadosTFIDF_O_S.add(id_score);
                    ResultadosTFIDF_O_S.add(rank);
                    ResultadosTFIDF_O_S.add(url);
                    ResultadosTFIDF_O_S.add(sum_tfidf_o_s);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_O_S los resultados
                    TFIDF_O_S.put(id_pagina, (ArrayList) ResultadosTFIDF_O_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_S:
            GuardarRankingScoreTFIDF_O_S(TFIDF_O_S, OpcionContenido);


            ////////////////////////////////////////////////////////
            //PASO 10: Se establece el ranking para OKAPI (OKAPI)
            ////////////////////////////////////////////////////////
            cdb.un_sql = " SELECT id_pagina, id_score, SUM(OKAPI) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(OKAPI) DESC LIMIT "+ Ranking;
            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_pagina:
                    id_pagina = cdb.resultado.getInt("id_pagina");
                    //Se obtiene el id_score:
                    id_score = cdb.resultado.getInt("id_score");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_okapi = cdb.resultado.getDouble("SUM(OKAPI)");
                    //Para el listado de páginas hacer:
                    for (int i=0; i<ListaPaginas.size(); i++)
                    {
                        //Si id_pagina del Select es igual al del listado:
                        if (ListaPaginas.get(i).getId_pagina() == id_pagina)
                        {
                            url = ListaPaginas.get(i).getUrl();
                            i = ListaPaginas.size();
                        }
                    }

                    //Se guarda en un arreglo OKAPI los datos:
                    List ResultadosOKAPI = new ArrayList();
                    ResultadosOKAPI.add(id_pagina);
                    ResultadosOKAPI.add(id_score);
                    ResultadosOKAPI.add(rank);
                    ResultadosOKAPI.add(url);
                    ResultadosOKAPI.add(sum_okapi);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_O_S los resultados
                    OKAPI.put(id_pagina, (ArrayList) ResultadosOKAPI);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_S:
            GuardarRankingScoreOKAPI(OKAPI, OpcionContenido);

        }//FIN IF BODY



        ////////////////////////////////////////////////////////////////////////
        // SURROUND TEXT  //////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////

        if (OpcionContenido == 2)
        {

            ////////////////////////////////////////////////////////////////////
            //PASO 1: Se establece el ranking para TF SIN NORMALIZAR (TF_SN) ST
            //        (OK)
            ////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_relacion_pag, id_score_st, SUM(TF_SN) FROM MEDICION_SCORE_ST GROUP BY id_relacion_pag ORDER BY SUM(TF_SN) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TF_SN), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TF_SN) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            
            
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TF_SN para los terminos de la consulta:
                    sum_tf_sn = cdb.resultado.getDouble("SUM(TF_SN)");

                    //Se guarda en un arreglo TF_SN los datos:
                    List ResultadosTF_SN = new ArrayList();
                    ResultadosTF_SN.add(id_relacion_pag);
                    ResultadosTF_SN.add(id_score_st);
                    ResultadosTF_SN.add(id_pagina_fuente);
                    ResultadosTF_SN.add(id_pagina_destino);
                    ResultadosTF_SN.add(url_origen);
                    ResultadosTF_SN.add(url_destino);
                    ResultadosTF_SN.add(sum_tf_sn);
                    ResultadosTF_SN.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_SN.put(id_relacion_pag, ResultadosTF_SN);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_SN(TF_SN, OpcionContenido);



            //////////////////////////////////////////////////////////////////
            //PASO 2: Se establece el ranking para TF NORMALISADO(TF_N)
            //        (OK)
            //////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TF_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TF_N) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TF_N), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TF_N) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TF_N para los terminos de la consulta:
                    sum_tf_n = cdb.resultado.getDouble("SUM(TF_N)");

                    //Se guarda en un arreglo TF_N los datos:
                    List ResultadosTF_N = new ArrayList();
                    ResultadosTF_N.add(id_relacion_pag);
                    ResultadosTF_N.add(id_score_st);
                    ResultadosTF_N.add(id_pagina_fuente);
                    ResultadosTF_N.add(id_pagina_destino);
                    ResultadosTF_N.add(url_origen);
                    ResultadosTF_N.add(url_destino);
                    ResultadosTF_N.add(sum_tf_n);
                    ResultadosTF_N.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_N.put(id_relacion_pag, ResultadosTF_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_N(TF_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////
            //PASO 3: Se establece el ranking para TF SUAVISADO (TF_S)
            //        (OK).
            //////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TF_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TF_S) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TF_S), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TF_S) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TF_S para los terminos de la consulta:
                    sum_tf_s = cdb.resultado.getDouble("SUM(TF_S)");

                    //Se guarda en un arreglo TF_S los datos:
                    List ResultadosTF_S = new ArrayList();
                    ResultadosTF_S.add(id_relacion_pag);
                    ResultadosTF_S.add(id_score_st);
                    ResultadosTF_S.add(id_pagina_fuente);
                    ResultadosTF_S.add(id_pagina_destino);
                    ResultadosTF_S.add(url_origen);
                    ResultadosTF_S.add(url_destino);
                    ResultadosTF_S.add(sum_tf_s);
                    ResultadosTF_S.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TF_SN los resultados
                    TF_S.put(id_relacion_pag, ResultadosTF_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTF_S(TF_S, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 4: Se establece el ranking para TFIDF SIN NORMALIZAR (TFIDF_SN)
            //        (OK).
            //////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_SN) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_SN) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_SN), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_SN) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_SN para los terminos de la consulta:
                    sum_tfidf_sn = cdb.resultado.getDouble("SUM(TFXIDF_SN)");

                    //Se guarda en un arreglo TFXIDF_SN los datos:
                    List ResultadosTFIDF_SN = new ArrayList();
                    ResultadosTFIDF_SN.add(id_relacion_pag);
                    ResultadosTFIDF_SN.add(id_score_st);
                    ResultadosTFIDF_SN.add(id_pagina_fuente);
                    ResultadosTFIDF_SN.add(id_pagina_destino);
                    ResultadosTFIDF_SN.add(url_origen);
                    ResultadosTFIDF_SN.add(url_destino);
                    ResultadosTFIDF_SN.add(sum_tfidf_sn);
                    ResultadosTFIDF_SN.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_SN.put(id_relacion_pag, ResultadosTFIDF_SN);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_SN(TFIDF_SN, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 5: Se establece el ranking para TFIDF NORMALISADO (TFIDF_N)
            //        (OK)
            //////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_N) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_N), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_N) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_N para los terminos de la consulta:
                    sum_tfidf_n = cdb.resultado.getDouble("SUM(TFXIDF_N)");

                    //Se guarda en un arreglo TFXIDF_N los datos:
                    List ResultadosTFIDF_N = new ArrayList();
                    ResultadosTFIDF_N.add(id_relacion_pag);
                    ResultadosTFIDF_N.add(id_score_st);
                    ResultadosTFIDF_N.add(id_pagina_fuente);
                    ResultadosTFIDF_N.add(id_pagina_destino);
                    ResultadosTFIDF_N.add(url_origen);
                    ResultadosTFIDF_N.add(url_destino);
                    ResultadosTFIDF_N.add(sum_tfidf_n);
                    ResultadosTFIDF_N.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_N.put(id_relacion_pag, ResultadosTFIDF_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_N(TFIDF_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////
            //PASO 6: Se establece el ranking para TFIDF SUAVISADO (TFIDF_S)
            //        (OK)
            //////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_S) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_S), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_S) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {
                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_S para los terminos de la consulta:
                    sum_tfidf_s = cdb.resultado.getDouble("SUM(TFXIDF_S)");

                    //Se guarda en un arreglo TFXIDF_S los datos:
                    List ResultadosTFIDF_S = new ArrayList();
                    ResultadosTFIDF_S.add(id_relacion_pag);
                    ResultadosTFIDF_S.add(id_score_st);
                    ResultadosTFIDF_S.add(id_pagina_fuente);
                    ResultadosTFIDF_S.add(id_pagina_destino);
                    ResultadosTFIDF_S.add(url_origen);
                    ResultadosTFIDF_S.add(url_destino);
                    ResultadosTFIDF_S.add(sum_tfidf_s);
                    ResultadosTFIDF_S.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_S.put(id_relacion_pag, ResultadosTFIDF_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_S(TFIDF_S, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////////
            //PASO 7: Se establece el ranking para TFIDF SIN NORMALIZAR OKAPI (TFIDF_O_SN)
            //        (OK)
            //////////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_SN) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_SN) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_O_SN), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_O_SN) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_O_SN para los terminos de la consulta:
                    sum_tfidf_o_sn = cdb.resultado.getDouble("SUM(TFXIDF_O_SN)");

                    //Se guarda en un arreglo TFXIDF_O_SN los datos:
                    List ResultadosTFIDF_O_SN = new ArrayList();
                    ResultadosTFIDF_O_SN.add(id_relacion_pag);
                    ResultadosTFIDF_O_SN.add(id_score_st);
                    ResultadosTFIDF_O_SN.add(id_pagina_fuente);
                    ResultadosTFIDF_O_SN.add(id_pagina_destino);
                    ResultadosTFIDF_O_SN.add(url_origen);
                    ResultadosTFIDF_O_SN.add(url_destino);
                    ResultadosTFIDF_O_SN.add(sum_tfidf_o_sn);
                    ResultadosTFIDF_O_SN.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_O_SN.put(id_relacion_pag, ResultadosTFIDF_O_SN);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TF_SN:
            GuardarRankingScoreTFIDF_O_SN(TFIDF_O_SN, OpcionContenido);




            //////////////////////////////////////////////////////////////////////////////
            //PASO 8: Se establece el ranking para TFIDF SIN NORMALIZADO OKAPI (TFIDF_O_N)
            //        (OK)
            //////////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_N) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_N) DESC LIMIT "+ Ranking +";";
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_O_N), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_O_N) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_O_N para los terminos de la consulta:
                    sum_tfidf_o_n = cdb.resultado.getDouble("SUM(TFXIDF_O_N)");

                    //Se guarda en un arreglo TFXIDF_O_N los datos:
                    List ResultadosTFIDF_O_N = new ArrayList();
                    ResultadosTFIDF_O_N.add(id_relacion_pag);
                    ResultadosTFIDF_O_N.add(id_score_st);
                    ResultadosTFIDF_O_N.add(id_pagina_fuente);
                    ResultadosTFIDF_O_N.add(id_pagina_destino);
                    ResultadosTFIDF_O_N.add(url_origen);
                    ResultadosTFIDF_O_N.add(url_destino);
                    ResultadosTFIDF_O_N.add(sum_tfidf_o_n);
                    ResultadosTFIDF_O_N.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_O_N.put(id_relacion_pag, ResultadosTFIDF_O_N);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_N:
            GuardarRankingScoreTFIDF_O_N(TFIDF_O_N, OpcionContenido);



            //////////////////////////////////////////////////////////////////////////////
            //PASO 9: Se establece el ranking para TFIDF SUAVISADO OKAPI (TFIDF_O_S)
            //        (OK)
            //////////////////////////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(TFXIDF_O_S) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(TFXIDF_O_S) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(TFXIDF_O_S), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(TFXIDF_O_S) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del TFXIDF_O_S para los terminos de la consulta:
                    sum_tfidf_o_s = cdb.resultado.getDouble("SUM(TFXIDF_O_S)");

                    //Se guarda en un arreglo TFXIDF_O_S los datos:
                    List ResultadosTFIDF_O_S = new ArrayList();
                    ResultadosTFIDF_O_S.add(id_relacion_pag);
                    ResultadosTFIDF_O_S.add(id_score_st);
                    ResultadosTFIDF_O_S.add(id_pagina_fuente);
                    ResultadosTFIDF_O_S.add(id_pagina_destino);
                    ResultadosTFIDF_O_S.add(url_origen);
                    ResultadosTFIDF_O_S.add(url_destino);
                    ResultadosTFIDF_O_S.add(sum_tfidf_o_s);
                    ResultadosTFIDF_O_S.add(rank);

                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    TFIDF_O_S.put(id_relacion_pag, ResultadosTFIDF_O_S);

                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_S:
            GuardarRankingScoreTFIDF_O_S(TFIDF_O_S, OpcionContenido);



            ////////////////////////////////////////////////////////
            //PASO 10: Se establece el ranking para OKAPI (OKAPI)
            //         (OK)
            ////////////////////////////////////////////////////////

            //cdb.un_sql = " SELECT id_pagina, id_score, SUM(OKAPI) FROM MEDICION_SCORE GROUP BY id_pagina ORDER BY SUM(OKAPI) DESC LIMIT "+ Ranking;
            cdb.un_sql = "SELECT mss.id_relacion_pag, mss.id_score_st, p1.URL AS ORIGEN, p2.URL AS DESTINO, SUM(OKAPI), rp.ID_PAGINA_FUENTE, rp.ID_PAGINA_DESTINO "+
                         "FROM MEDICION_SCORE_ST AS mss "+
                         "INNER JOIN RELACION_PAGINAS AS rp "+
                         "ON rp.ID_RELACION_PAG = mss.ID_RELACION_PAG "+
                         "INNER JOIN PAGINA AS p1 "+
                         "ON p1.ID_PAGINA = rp.ID_PAGINA_FUENTE "+
                         "INNER JOIN PAGINA AS p2 "+
                         "ON p2.ID_PAGINA = rp.ID_PAGINA_DESTINO "+
                         "GROUP BY id_relacion_pag "+
                         "ORDER BY SUM(OKAPI) "+
                         "DESC LIMIT "+ Ranking;

            cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
            if (cdb.resultado != null)
            {

                while (cdb.resultado.next())
                {
                    //Se obtiene el id_relacion_pag:
                    id_relacion_pag = cdb.resultado.getInt("id_relacion_pag");
                    //Se obtiene el id_score_st:
                    id_score_st = cdb.resultado.getInt("id_score_st");
                    //Se obtiene el id de la pagina Origen:
                    id_pagina_fuente = cdb.resultado.getInt("id_pagina_fuente");
                    //Se obtiene el id de la pagina Destino:
                    id_pagina_destino = cdb.resultado.getInt("id_pagina_destino");
                    //Se obtiene la URL Origen:
                    url_origen = cdb.resultado.getString("ORIGEN");
                    //Se obtiene la URL Destino:
                    url_destino = cdb.resultado.getString("DESTINO");
                    //Se obtiene la suma del OKAPI para los terminos de la consulta:
                    sum_okapi = cdb.resultado.getDouble("SUM(OKAPI)");

                    //Se guarda en un arreglo OKAPI los datos:
                    List ResultadosOKAPI = new ArrayList();
                    ResultadosOKAPI.add(id_relacion_pag);
                    ResultadosOKAPI.add(id_score_st);
                    ResultadosOKAPI.add(id_pagina_fuente);
                    ResultadosOKAPI.add(id_pagina_destino);
                    ResultadosOKAPI.add(url_origen);
                    ResultadosOKAPI.add(url_destino);
                    ResultadosOKAPI.add(sum_okapi);
                    ResultadosOKAPI.add(rank);
                    //Se aumenta el rank:
                    rank++;

                    //Se almacena en el Map TFIDF_SN los resultados
                    OKAPI.put(id_relacion_pag, ResultadosOKAPI);


                }//FIN while

            }//FIN if

            //Se resetea el ranking:
            rank = 1;
            //Se invoca a la función que guarda en BD el ranking para TFIDF_O_S:
            GuardarRankingScoreOKAPI(OKAPI, OpcionContenido);


        }//FIN IF SURROUND TEXT


    }//FIN RankingScores


    /**
     * @brief Guarda el ranking para TF_SN segun contenido.
     * @param Listado de mediciones TF_SN y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTF_SN(Map<Integer, List> TF_SN, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_SN = new ArrayList();
                ListaTF_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_SN(id_pagina, id_score, ranking_tf_sn, url, tf_sn) VALUES"
                             + "('" + ListaTF_SN.get(0) + "','" + ListaTF_SN.get(1) + "','" +  ListaTF_SN.get(2) + "','" + ListaTF_SN.get(3) + "','" + ListaTF_SN.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF BODY


        ////////////////////////////////////////////////////////////////////////////////
        // SURROUND TEXT  //
        ////////////////////
        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_SN = new ArrayList();
                ListaTF_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_SN_ST(id_relacion_pag, id_score_st, ranking_tf_sn_st, url_origen, url_destino, tf_sn_st) VALUES"
                             + "('" + ListaTF_SN.get(0) + "','" + ListaTF_SN.get(1) + "','" +  ListaTF_SN.get(7) + "','" + ListaTF_SN.get(4) + "','" + ListaTF_SN.get(5) + "','" + ListaTF_SN.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (1) FIN GuardarRankingScoreTF_SN


    /**
     * @brief Guarda el ranking para TF_N segun contenido.
     * @param Listado de mediciones TF_N y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTF_N(Map<Integer, List> TF_N, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_N = new ArrayList();
                ListaTF_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_N(id_pagina, id_score, ranking_tf_n, url, tf_n) VALUES"
                             + "('" + ListaTF_N.get(0) + "','" + ListaTF_N.get(1) + "','" +  ListaTF_N.get(2) + "','" + ListaTF_N.get(3) + "','" + ListaTF_N.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF BODY


        ////////////////////////////////////////////////////////////////////////////////
        // SURROUND TEXT  //
        ////////////////////
        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_N = new ArrayList();
                ListaTF_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_N_ST(id_relacion_pag, id_score_st, ranking_tf_n_st, url_origen, url_destino, tf_n_st) VALUES"
                             + "('" + ListaTF_N.get(0) + "','" + ListaTF_N.get(1) + "','" +  ListaTF_N.get(7) + "','" + ListaTF_N.get(4) + "','" + ListaTF_N.get(5) + "','" + ListaTF_N.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (2) FIN GuardarRankingScoreTF_N


    /**
     * @brief Guarda el ranking para TF_S segun contenido.
     * @param Listado de mediciones TF_S y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTF_S(Map<Integer, List> TF_S, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_S = new ArrayList();
                ListaTF_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_S(id_pagina, id_score, ranking_tf_s, url, tf_s) VALUES"
                             + "('" + ListaTF_S.get(0) + "','" + ListaTF_S.get(1) + "','" +  ListaTF_S.get(2) + "','" + ListaTF_S.get(3) + "','" + ListaTF_S.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY


        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TF_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTF_S = new ArrayList();
                ListaTF_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TF_S_ST(id_relacion_pag, id_score_st, ranking_tf_s_st, url_origen, url_destino, tf_s_st) VALUES"
                             + "('" + ListaTF_S.get(0) + "','" + ListaTF_S.get(1) + "','" +  ListaTF_S.get(7) + "','" + ListaTF_S.get(4) + "','" + ListaTF_S.get(5) + "','" + ListaTF_S.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (3) FIN GuardarRankingScoreTF_S



    /**
     * @brief Guarda el ranking para TFIDF_SN segun contenido.
     * @param Listado de mediciones TFIDF_SN y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_SN(Map<Integer, List> TFIDF_SN, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_SN = new ArrayList();
                ListaTFIDF_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_SN(id_pagina, id_score, ranking_tfidf_sn, url, tfidf_sn) VALUES"
                             + "('" + ListaTFIDF_SN.get(0) + "','" + ListaTFIDF_SN.get(1) + "','" +  ListaTFIDF_SN.get(2) + "','" + ListaTFIDF_SN.get(3) + "','" + ListaTFIDF_SN.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY


        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_SN= new ArrayList();
                ListaTFIDF_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_SN_ST(id_relacion_pag, id_score_st, ranking_tfidf_sn_st, url_origen, url_destino, tfidf_sn_st) VALUES"
                             + "('" + ListaTFIDF_SN.get(0) + "','" + ListaTFIDF_SN.get(1) + "','" +  ListaTFIDF_SN.get(7) + "','" + ListaTFIDF_SN.get(4) + "','" + ListaTFIDF_SN.get(5) + "','" + ListaTFIDF_SN.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (4) FIN GuardarRankingScoreTFIDF_SN


    /**
     * @brief Guarda el ranking para TFIDF_N segun contenido.
     * @param Listado de mediciones TFIDF_N y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_N(Map<Integer, List> TFIDF_N, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {

            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_N = new ArrayList();
                ListaTFIDF_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_N(id_pagina, id_score, ranking_tfidf_n, url, tfidf_n) VALUES"
                             + "('" + ListaTFIDF_N.get(0) + "','" + ListaTFIDF_N.get(1) + "','" +  ListaTFIDF_N.get(2) + "','" + ListaTFIDF_N.get(3) + "','" + ListaTFIDF_N.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY



        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TFIDF_N hacer:
            Set set = TFIDF_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_N = new ArrayList();
                ListaTFIDF_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_N_ST(id_relacion_pag, id_score_st, ranking_tfidf_n_st, url_origen, url_destino, tfidf_n_st) VALUES"
                             + "('" + ListaTFIDF_N.get(0) + "','" + ListaTFIDF_N.get(1) + "','" +  ListaTFIDF_N.get(7) + "','" + ListaTFIDF_N.get(4) + "','" + ListaTFIDF_N.get(5) + "','" + ListaTFIDF_N.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (5) FIN GuardarRankingScoreTFIDF_N


    /**
     * @brief Guarda el ranking para TFIDF_S segun contenido.
     * @param Listado de mediciones TFIDF_S y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_S(Map<Integer, List> TFIDF_S, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {

            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_S = new ArrayList();
                ListaTFIDF_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_S(id_pagina, id_score, ranking_tfidf_s, url, tfidf_s) VALUES"
                             + "('" + ListaTFIDF_S.get(0) + "','" + ListaTFIDF_S.get(1) + "','" +  ListaTFIDF_S.get(2) + "','" + ListaTFIDF_S.get(3) + "','" + ListaTFIDF_S.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY


        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TFIDF_S hacer:
            Set set = TFIDF_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_S = new ArrayList();
                ListaTFIDF_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_S_ST(id_relacion_pag, id_score_st, ranking_tfidf_s_st, url_origen, url_destino, tfidf_s_st) VALUES"
                             + "('" + ListaTFIDF_S.get(0) + "','" + ListaTFIDF_S.get(1) + "','" +  ListaTFIDF_S.get(7) + "','" + ListaTFIDF_S.get(4) + "','" + ListaTFIDF_S.get(5) + "','" + ListaTFIDF_S.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT


    }// (6) FIN GuardarRankingScoreTFIDF_S



    /**
     * @brief Guarda el ranking para TFIDF_O_SN segun contenido.
     * @param Listado de mediciones TFIDF_O_SN y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_O_SN(Map<Integer, List> TFIDF_O_SN, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {

            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_O_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_SN = new ArrayList();
                ListaTFIDF_O_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_SN(id_pagina, id_score, ranking_tfidf_o_sn, url, tfidf_o_sn) VALUES"
                             + "('" + ListaTFIDF_O_SN.get(0) + "','" + ListaTFIDF_O_SN.get(1) + "','" +  ListaTFIDF_O_SN.get(2) + "','" + ListaTFIDF_O_SN.get(3) + "','" + ListaTFIDF_O_SN.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY



        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TFIDF_S hacer:
            Set set = TFIDF_O_SN.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_SN = new ArrayList();
                ListaTFIDF_O_SN = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_SN_ST(id_relacion_pag, id_score_st, ranking_tfidf_o_sn_st, url_origen, url_destino, tfidf_o_sn_st) VALUES"
                             + "('" + ListaTFIDF_O_SN.get(0) + "','" + ListaTFIDF_O_SN.get(1) + "','" +  ListaTFIDF_O_SN.get(7) + "','" + ListaTFIDF_O_SN.get(4) + "','" + ListaTFIDF_O_SN.get(5) + "','" + ListaTFIDF_O_SN.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT



    }// (7) FIN GuardarRankingScoreTFIDF_O_SN



    /**
     * @brief Guarda el ranking para TFIDF_O_N segun contenido.
     * @param Listado de mediciones TFIDF_O_N y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_O_N(Map<Integer, List> TFIDF_O_N, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TFIDF_O_N hacer:
            Set set = TFIDF_O_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_N = new ArrayList();
                ListaTFIDF_O_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_N(id_pagina, id_score, ranking_tfidf_o_n, url, tfidf_o_n) VALUES"
                             + "('" + ListaTFIDF_O_N.get(0) + "','" + ListaTFIDF_O_N.get(1) + "','" +  ListaTFIDF_O_N.get(2) + "','" + ListaTFIDF_O_N.get(3) + "','" + ListaTFIDF_O_N.get(4) + "');";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY



        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TFIDF_S hacer:
            Set set = TFIDF_O_N.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_N = new ArrayList();
                ListaTFIDF_O_N = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_N_ST(id_relacion_pag, id_score_st, ranking_tfidf_o_n_st, url_origen, url_destino, tfidf_o_n_st) VALUES"
                             + "('" + ListaTFIDF_O_N.get(0) + "','" + ListaTFIDF_O_N.get(1) + "','" +  ListaTFIDF_O_N.get(7) + "','" + ListaTFIDF_O_N.get(4) + "','" + ListaTFIDF_O_N.get(5) + "','" + ListaTFIDF_O_N.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT
       


    }// (8) FIN GuardarRankingScoreTFIDF_O_N



    /**
     * @brief Guarda el ranking para TFIDF_O_S segun contenido.
     * @param Listado de mediciones TFIDF_O_S y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreTFIDF_O_S(Map<Integer, List> TFIDF_O_S, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = TFIDF_O_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_S = new ArrayList();
                ListaTFIDF_O_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_S(id_pagina, id_score, ranking_tfidf_o_s, url, tfidf_o_s) VALUES"
                             + "('" + ListaTFIDF_O_S.get(0) + "','" + ListaTFIDF_O_S.get(1) + "','" +  ListaTFIDF_O_S.get(2) + "','" + ListaTFIDF_O_S.get(3) + "','" + ListaTFIDF_O_S.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY



        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map TFIDF_O_S hacer:
            Set set = TFIDF_O_S.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaTFIDF_O_S = new ArrayList();
                ListaTFIDF_O_S = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_TFIDF_O_S_ST(id_relacion_pag, id_score_st, ranking_tfidf_o_s_st, url_origen, url_destino, tfidf_o_s_st) VALUES"
                             + "('" + ListaTFIDF_O_S.get(0) + "','" + ListaTFIDF_O_S.get(1) + "','" +  ListaTFIDF_O_S.get(7) + "','" + ListaTFIDF_O_S.get(4) + "','" + ListaTFIDF_O_S.get(5) + "','" + ListaTFIDF_O_S.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT



    }// (9) FIN GuardarRankingScoreTFIDF_O_S



    /**
     * @brief Guarda el ranking para OKAPI segun contenido.
     * @param Listado de mediciones OKAPI y OpcionContenido.
     * @return void
    */
    public void GuardarRankingScoreOKAPI(Map<Integer, List> OKAPI, int OpcionContenido) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_pagina;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        ////////////////////////////////////////////////////////////////////////
        //PASO 0: Segun la selección de OpcionContenido (1:BODY/2:SURROUND TEXT)
        //        se calcula el tf:
        ////////////////////////////////////////////////////////////////////////

        ////////////
        // BODY   //
        ////////////
        if (OpcionContenido == 1)
        {
            //Para cada elemento del Map TF_SN hacer:
            Set set = OKAPI.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaOKAPI = new ArrayList();
                ListaOKAPI = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_OKAPI(id_pagina, id_score, ranking_okapi, url, okapi) VALUES"
                             + "('" + ListaOKAPI.get(0) + "','" + ListaOKAPI.get(1) + "','" +  ListaOKAPI.get(2) + "','" + ListaOKAPI.get(3) + "','" + ListaOKAPI.get(4) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }
        }//FIN IF BODY



        ////////////////////
        // SURROUND TEXT  //
        ////////////////////

        if (OpcionContenido == 2)
        {
            //Para cada elemento del Map OKAPI hacer:
            Set set = OKAPI.entrySet();
            Iterator i = set.iterator();

            while(i.hasNext())
            {
                //Se obtiene el par:
                Map.Entry me = (Map.Entry)i.next();
                //Se obtiene el id_pagina:
                id_pagina = (Integer) me.getKey();
                //Se obtiene el ArrayList con los datos:
                List ListaOKAPI = new ArrayList();
                ListaOKAPI = (List) me.getValue();

                //Se guarda en la BD el resultado:
                cdb.un_sql = "INSERT INTO RANKING_OKAPI_ST(id_relacion_pag, id_score_st, ranking_okapi_st, url_origen, url_destino, okapi_st) VALUES"
                             + "('" + ListaOKAPI.get(0) + "','" + ListaOKAPI.get(1) + "','" +  ListaOKAPI.get(7) + "','" + ListaOKAPI.get(4) + "','" + ListaOKAPI.get(5) + "','" + ListaOKAPI.get(6) + "')";
                cdb.un_st.executeUpdate(cdb.un_sql);

            }

        }//FIN IF SURROUND TEXT



    }// (10) FIN GuardarRankingScoreOKAPI



    /**
     * @brief Extrae el id de la página de mejor puntaje para TF_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTF_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTF_SN = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TF_SN WHERE RANKING_TF_SN.RANKING_TF_SN = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTF_SN = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTF_SN;
        
    }//FIN ObtenerMejorPaginaTF_SN


    /**
     * @brief Extrae el id la página de mejor puntaje para TF_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTF_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTF_N= 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TF_N WHERE RANKING_TF_N.RANKING_TF_N = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTF_N = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTF_N;

    }//FIN ObtenerMejorPaginaTF_N


    /**
     * @brief Extrae el id la página de mejor puntaje para TF_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTF_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTF_S= 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TF_S WHERE RANKING_TF_S.RANKING_TF_S = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTF_S = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTF_S;

    }//FIN ObtenerMejorPaginaTF_S


    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_SN= 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_SN WHERE RANKING_TFIDF_SN.RANKING_TFIDF_SN = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_SN = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_SN;

    }//FIN ObtenerMejorPaginaTFIDF_SN


    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_N= 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_N WHERE RANKING_TFIDF_N.RANKING_TFIDF_N = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_N = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_N;

    }//FIN ObtenerMejorPaginaTFIDF_N



    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_S= 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_S WHERE RANKING_TFIDF_S.RANKING_TFIDF_S = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_S = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_S;

    }//FIN ObtenerMejorPaginaTFIDF_S


    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_O_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_O_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_O_SN = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_O_SN WHERE RANKING_TFIDF_O_SN.RANKING_TFIDF_O_SN = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_O_SN = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_O_SN;

    }//FIN ObtenerMejorPaginaTFIDF_O_SN



    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_O_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_O_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_O_N = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_O_N WHERE RANKING_TFIDF_O_N.RANKING_TFIDF_O_N = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_O_N = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_O_N;

    }//FIN ObtenerMejorPaginaTFIDF_O_N


    /**
     * @brief Extrae el id la página de mejor puntaje para TFIDF_O_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaTFIDF_O_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaTFIDF_O_S = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_TFIDF_O_S WHERE RANKING_TFIDF_O_S.RANKING_TFIDF_O_S = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaTFIDF_O_S = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaTFIDF_O_S;

    }//FIN ObtenerMejorPaginaTFIDF_O_S



    /**
     * @brief Extrae el id la página de mejor puntaje para OKAPI.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorPaginaOKAPI(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_paginaOKAPI = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_pagina FROM RANKING_OKAPI WHERE RANKING_OKAPI.RANKING_OKAPI = 1 ORDER BY id_pagina DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_paginaOKAPI = cdb.resultado.getInt("id_pagina");
            }
        }
        return id_paginaOKAPI;

    }//FIN ObtenerMejorPaginaOKAPI


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TF_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TF_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TF_SN = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TF_SN_ST WHERE RANKING_TF_SN_ST.RANKING_TF_SN_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TF_SN = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TF_SN;

    }//FIN ObtenerMejorST_TF_SN


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TF_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TF_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TF_N = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TF_N_ST WHERE RANKING_TF_N_ST.RANKING_TF_N_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TF_N = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TF_N;

    }//FIN ObtenerMejorST_TF_N


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TF_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TF_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TF_S = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TF_S_ST WHERE RANKING_TF_S_ST.RANKING_TF_S_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TF_S = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TF_S;

    }//FIN ObtenerMejorST_TF_S


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_SN = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_SN_ST WHERE RANKING_TFIDF_SN_ST.RANKING_TFIDF_SN_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_SN= cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_SN;

    }//FIN ObtenerMejorTFIDF_SN


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_N = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_N_ST WHERE RANKING_TFIDF_N_ST.RANKING_TFIDF_N_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_N= cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_N;

    }//FIN ObtenerMejorTFIDF_N


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_S = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_S_ST WHERE RANKING_TFIDF_S_ST.RANKING_TFIDF_S_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_S= cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_S;

    }//FIN ObtenerMejorTFIDF_S


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_O_SN.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_O_SN(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_O_SN = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_O_SN_ST WHERE RANKING_TFIDF_O_SN_ST.RANKING_TFIDF_O_SN_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_O_SN= cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_O_SN;

    }//FIN ObtenerMejorTFIDF_O_SN


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_O_N.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_O_N(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_O_N = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_O_N_ST WHERE RANKING_TFIDF_O_N_ST.RANKING_TFIDF_O_N_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_O_N = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_O_N;

    }//FIN ObtenerMejorTFIDF_O_N


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para TFIDF_O_S.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_TFIDF_O_S(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_TFIDF_O_S = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_TFIDF_O_S_ST WHERE RANKING_TFIDF_O_S_ST.RANKING_TFIDF_O_S_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_TFIDF_O_S = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_TFIDF_O_S;

    }//FIN ObtenerMejorST_TFIDF_O_S


    /**
     * @brief Extrae el id del texto alrededor de mejor puntaje para OKAPI.
     * @param Tamaño del Ranking.
     * @return int
    */
    public int ObtenerMejorST_OKAPI(int Ranking) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException, SQLException
    {
        int id_ST_OKAPI = 0;

        //Se inicia la conexión a la BD:
        Conexion cdb = FactoriaServicios.getInstancia().getConexionBD();

        cdb.un_sql = "SELECT id_relacion_pag FROM RANKING_OKAPI_ST WHERE RANKING_OKAPI_ST.RANKING_OKAPI_ST = 1 ORDER BY id_relacion_pag DESC LIMIT "+ Ranking;
        cdb.resultado = cdb.un_st.executeQuery(cdb.un_sql);
        if (cdb.resultado != null)
        {
            if (cdb.resultado.next())
            {
                id_ST_OKAPI = cdb.resultado.getInt("id_relacion_pag");
            }
        }
        return id_ST_OKAPI;

    }//FIN ObtenerMejorST_OKAPI


}//FIN CLASE ScoreBD
